
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.brain.capa.view.mbean;

import com.brain.capa.dto.AlumnoDto;
import com.brain.capa.dto.ProgramacionDto;
import com.brain.capa.dto.RequerimientoCapaDto;
import com.brain.capa.dto.RoiDto;
import com.brain.capa.manager.AlumnoManager;
import com.brain.capa.manager.ProgramacionManager;
import com.brain.capa.manager.RequerimientoCapaManager;
import com.brain.capa.manager.RoiManager;
import com.brain.capa.view.util.ConstantesCapa;
import com.brain.core.common.UtilCore;
import com.brain.core.dto.ParametroDto;
import com.brain.core.exception.DAOException;
import com.brain.core.view.mbean.*;
import com.brain.core.manager.RecursosManager;
import com.brain.core.view.util.ConstantesCore;
import com.brain.sgc.dto.PersonaDto;
import com.brain.sgc.view.util.ConstantesSgc;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.annotation.Resource;
import javax.faces.event.ActionEvent;
import org.apache.log4j.Logger;
import org.primefaces.context.RequestContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;

/**
 *
 * @author Hvives
 */
@Controller("programacionMBean")
@Scope("session")
public class ProgramacionMBean extends GenericMBean implements Serializable {

    private static Logger logger = Logger.getLogger(ProgramacionMBean.class);
    @Resource
    private RecursosManager recursosManager;
    @Resource
    private ProgramacionManager manager;
    @Resource
    private RequerimientoCapaManager requerimientoCapaManager;
    @Resource
    private AlumnoManager alumnoManager;
    @Resource
    private RoiManager roiManager;
    private List<ProgramacionDto> lista;
    private ProgramacionDto dto;
    private ProgramacionDto dtoFiltro;
    private RequerimientoCapaDto requerimientoCapaDto;
    private RequerimientoCapaDto dtoRequerimientoCapa;
    private RequerimientoCapaDto dtoRequerimientoCapaRio;
    private RoiDto roiDto;
    private String keyTitulo = "programacion.panel";
    @Autowired
    private ApplicationMBean applicationMBean;
    @Autowired
    private SessionMBean sessionMBean;
    private List<ParametroDto> listaEstadosFiltro;
    private List<ParametroDto> listaEstados;
    private List<AlumnoDto> listaAlumno;
    private List<RoiDto> listaRoi;
    private AlumnoDto alumnoDto;
    private AlumnoDto alumnoDetalleDto;
    private List<RequerimientoCapaDto> listaRequerimiento;
    private List<RequerimientoCapaDto> listaRequerimientoPopUp;
    private RequerimientoCapaDto[] selectedRquerimiento;
    private PersonaDto[] selectedPersona;
    private boolean accesoAnular;
    private boolean accesoGuardar;
    private boolean accesoConvocado;
    private boolean accesoEjecutado;
    private boolean validarEliminarReq;
    private boolean validarEstadoAcciones;
    private boolean validarEstadoAccionesEjecutado;
    private BigDecimal retornoInvRoi;
    private Date fechaActual;
    private int numAlumnos;

    public ProgramacionMBean() {
        this.dtoFiltro = new ProgramacionDto();
    }

    public String iniciar() {
        this.dto = null;
        this.lista = null;
        this.dtoFiltro = new ProgramacionDto();
        return ConstantesCapa.UrlNavegacion.URL_LISTA_PROGRAMACIONES;
    }

    public String nuevo() {
        sessionMBean.setAccion(ConstantesSgc.Formulario.NUEVO);
        sessionMBean.setTitulo(recursosManager.construirTitulo(keyTitulo, sessionMBean.getAccion()));
        this.dto = manager.inicializar();
        gestionAcceso();
        this.numAlumnos = 0;
        return ConstantesCapa.UrlNavegacion.URL_PROGRAMACION;
    }

    public String editar() {
        sessionMBean.setAccion(ConstantesSgc.Formulario.EDITAR);
        sessionMBean.setTitulo(recursosManager.construirTitulo(keyTitulo, sessionMBean.getAccion()));
        gestionAcceso();
        this.requerimientoCapaDto = new RequerimientoCapaDto();
        obtenerListaRequerimiento();
        cargarListaAlumnoPorProgramacion();
        return ConstantesCapa.UrlNavegacion.URL_PROGRAMACION;
    }

    public String ver() {
        sessionMBean.setAccion(ConstantesSgc.Formulario.VER);
        sessionMBean.setTitulo(recursosManager.construirTitulo(keyTitulo, sessionMBean.getAccion()));        
        return ConstantesCapa.UrlNavegacion.URL_PROGRAMACION;
    }

    public void buscar(ActionEvent ae) {

        try {
            this.lista = this.manager.obtenerRequerimientosFiltro(this.dtoFiltro);
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public String guardar() {
        try {
            ProgramacionDto dtoProgra = this.dto;
            this.dto.setEstadoDto(new ParametroDto(ConstantesCapa.Parametro.PROGRAMACION_ACTIVO));
            this.manager.guardar(this.dto);
            if (this.dto != null) {
                this.dto = this.manager.obtenerPorId(this.dto.getId());
                return editar();
            } else {
                this.dto = dtoProgra;
            }
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        return "";
    }

    public String convocado() {
        Boolean result = Boolean.FALSE;
        try {

            for (RequerimientoCapaDto r : this.listaRequerimiento) {
                if (r.getFechaInicio() != null && r.getFechaFin() != null) {
                    if (UtilCore.Fecha.diferenciaDiasFechas(r.getFechaFin(), r.getFechaInicio()) > 0) {
                        showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("capacitacion.mensaje.error_fechas") + " " + r.getDescripcion());
                    } else {
                        result = true;
                    }
                } else {
                    showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("capacitacion.mensaje.error_fechas") + " " + r.getDescripcion());
                }
            }
            if (validarListaAlumnoPorRequerimiento() == false) {
                showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("programacion.mensaje.alumnos.requerimiento.vacio")+ " " + this.dto.getDescripcion());
            } else {
                if (result == true) {
                    ProgramacionDto dtoProgra = this.dto;
                    this.dto.setEstadoDto(new ParametroDto(ConstantesCapa.Parametro.PROGRAMACION_CONVOCADO));
                    this.dto.setNumAlumnos((long) this.numAlumnos);
                    this.manager.guardar(this.dto);
                    if (this.dto != null) {
                        this.dto = this.manager.obtenerPorId(this.dto.getId());
                        return editar();
                    } else {
                        this.dto = dtoProgra;
                    }
                }
            }
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        return "";
    }

    public String anular() {
        try {
            ProgramacionDto dtoProgra = this.dto;
            this.dto.setEstadoDto(new ParametroDto(ConstantesCapa.Parametro.PROGRAMACION_CANCELADO));
            this.dto.setNumAlumnos((long) this.numAlumnos);
            this.manager.guardar(this.dto);
            if (this.dto != null) {
                this.dto = this.manager.obtenerPorId(this.dto.getId());
                return editar();
            } else {
                this.dto = dtoProgra;
            }
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        return "";

    }

    public String ejecutado() {
        try {
            ProgramacionDto dtoProgra = this.dto;
            this.dto.setFechaEjecucion(UtilCore.Fecha.obtenerFechaActualDate());
            this.dto.setUsuarioEjecucion(sessionMBean.getSessionUsuarioDto().getId());
            this.dto.setEstadoDto(new ParametroDto(ConstantesCapa.Parametro.PROGRAMACION_EJECUTADO));
            this.dto.setNumAlumnos((long) this.numAlumnos);
            //Actualizamos la fecha y usuario de ejecucion de los requerimientos asociados
            for (RequerimientoCapaDto r : this.listaRequerimiento) {
                r.setFechaEjecucion(UtilCore.Fecha.obtenerFechaActualDate());
                r.setUsuarioEjecucion(sessionMBean.getSessionUsuarioDto().getId());
                this.requerimientoCapaManager.editar(r);
            }
            this.manager.guardar(this.dto);
            if (this.dto != null) {
                this.dto = this.manager.obtenerPorId(this.dto.getId());
                return editar();
            } else {
                this.dto = dtoProgra;
            }
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        return "";
    }

    public String anulado() {
        try {
            ProgramacionDto dtoProgra = this.dto;
            this.dto.setEstadoDto(new ParametroDto(ConstantesCapa.Parametro.PROGRAMACION_CANCELADO));
            this.dto.setNumAlumnos((long) this.numAlumnos);
            this.manager.guardar(this.dto);
            if (this.dto != null) {
                this.dto = this.manager.obtenerPorId(this.dto.getId());
                return editar();
            } else {
                this.dto = dtoProgra;
            }
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        return "";
    }

    public String retroceder() {
        buscar(null);
        sessionMBean.setAccion(ConstantesSgc.Formulario.LISTA);
        sessionMBean().setTitulo(recursosManager.construirTitulo(keyTitulo, sessionMBean().getAccion()));
        return ConstantesCapa.UrlNavegacion.URL_LISTA_PROGRAMACIONES;
    }

    public void gestionAcceso() {
        this.accesoAnular = false;
        this.accesoGuardar = true;
        if (dto.getId() != null) {
            if (dto.getEstadoDto().getId().equals(ConstantesCapa.Parametro.PROGRAMACION_ACTIVO)) {
                this.accesoAnular = false;
                this.accesoGuardar = false;
                this.accesoConvocado = false;
                this.accesoEjecutado = true;
                this.validarEstadoAcciones = false;
                this.validarEstadoAccionesEjecutado = true;
            } else if (dto.getEstadoDto().getId().equals(ConstantesCapa.Parametro.PROGRAMACION_CONVOCADO)) {
                this.accesoAnular = false;
                this.accesoGuardar = true;
                this.accesoConvocado = true;
                this.accesoEjecutado = false;
                this.validarEstadoAcciones = true;
                this.validarEstadoAccionesEjecutado = true;
            } else if (dto.getEstadoDto().getId().equals(ConstantesCapa.Parametro.PROGRAMACION_EJECUTADO)) {
                this.accesoAnular = true;
                this.accesoGuardar = true;
                this.accesoConvocado = true;
                this.accesoEjecutado = true;
                this.validarEstadoAcciones = true;
                this.validarEstadoAccionesEjecutado = false;
            } else if (dto.getEstadoDto().getId().equals(ConstantesCapa.Parametro.PROGRAMACION_CANCELADO)) {
                this.accesoAnular = true;
                this.accesoGuardar = true;
                this.accesoConvocado = true;
                this.accesoEjecutado = true;
                this.validarEstadoAcciones = true;
                this.validarEstadoAccionesEjecutado = true;
            }

            //Si la accion es = VER
            if (sessionMBean.getAccion() == 3) {
                this.accesoAnular = true;
                this.accesoGuardar = true;
                this.accesoConvocado = true;
                this.accesoEjecutado = true;
                this.validarEstadoAcciones = true;
                this.validarEstadoAccionesEjecutado = true;
            }
        } else {
            this.accesoAnular = true;
            this.accesoGuardar = false;
            this.accesoConvocado = true;
            this.accesoEjecutado = true;
            this.validarEstadoAcciones = true;
            this.validarEstadoAccionesEjecutado = true;
        }
    }

    protected void obtenerListaRequerimiento() {
        try {
            this.listaRequerimiento = this.requerimientoCapaManager.obtenerListaRequerimientoProgramacion(this.dto);
            this.requerimientoCapaDto = new RequerimientoCapaDto();
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }

    }

    public Boolean validarListaAlumnoPorRequerimiento() {
        Boolean validar = Boolean.TRUE;
        int numalum = 0;
        try {
            List<AlumnoDto> alumnoListProgra = new ArrayList<AlumnoDto>();
            alumnoListProgra = this.alumnoManager.obtenerListaAlumnoPorProgramaDto(this.dto);
            numalum = alumnoListProgra.size();
            if (numalum == 0) {
                validar = false;
            }
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        return validar;
    }

    public void cargarListaAlumnoPorProgramacion() {
        try {
            List<AlumnoDto> alumnoListProgra = new ArrayList<AlumnoDto>();
            alumnoListProgra = this.alumnoManager.obtenerListaAlumnoPorProgramaDto(this.dto);
            this.numAlumnos = alumnoListProgra.size();
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public void cargarListaAlumno() {
        try {
            this.listaAlumno = this.alumnoManager.obtenerListaAlumno(this.requerimientoCapaDto);
            this.cargarListaAlumnoPorProgramacion();
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public void cargarPopUpRoi() {
        this.roiDto = new RoiDto();
        this.dtoRequerimientoCapaRio = this.requerimientoCapaDto;
        // int valorIdRoi=this.requerimientoCapaDto.getRoiDto().getId().intValue();
        System.out.print("fsfdsf" + this.dtoRequerimientoCapaRio.getRoiDto());
        this.retornoInvRoi = null;
        try {

            if (this.dtoRequerimientoCapaRio.getRoiDto() != null) {
                System.out.print("entro");
                this.roiDto = this.roiManager.obtenerPorId(this.dtoRequerimientoCapaRio.getRoiDto().getId());
                devolucionInversionRoi();
            }

        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public void cargarPopupAlumnoDetalle() {
        this.alumnoDetalleDto = null;
        try {
            this.alumnoDetalleDto = this.alumnoManager.obtenerPorId(this.alumnoDto.getId());
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public void guardarDtalleAlumno() {
        try {
            if (this.requerimientoCapaDto.getCursoDto().getHora().compareTo(this.alumnoDto.getAsistencia()) >= 0) {
                if (this.alumnoDto.getAsistencia().compareTo(this.requerimientoCapaDto.getCursoDto().getAsistenciaMinima()) < 0) {
                    this.alumnoDto.setCertificado(Boolean.FALSE);
                } else {
                    this.alumnoDto.setCertificado(Boolean.TRUE);
                }
                this.alumnoDto.setAsistenciaPorcentaje(CalcularporcentajeAsistencia(this.alumnoDto.getAsistencia(), this.requerimientoCapaDto.getCursoDto().getHora()));
                this.alumnoManager.editar(alumnoDto);
                showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
            } else {
                this.alumnoDetalleDto.setAsistencia(null);
                showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("programacion.mensaje.alumnos.detalle.horas.error") +" : "+ this.requerimientoCapaDto.getCursoDto().getDescripcion());
            }
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public void guardarRoi() {
        try {
            if (this.roiDto.getId() != null) {
                this.roiManager.editar(this.roiDto);
                showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
            } else {
                this.roiManager.nuevo(this.roiDto);
                if (this.roiDto != null) {
                    System.out.print("roi id " + this.roiDto.getId());
                    System.out.print("reque id " + this.dtoRequerimientoCapaRio.getId());
                    this.dtoRequerimientoCapaRio.setRoiDto(this.roiDto);
                    this.requerimientoCapaManager.editar(this.dtoRequerimientoCapaRio);
                    showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
                }
            }
            devolucionInversionRoi();
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    protected void devolucionInversionRoi() {
        if (this.roiDto.getRetornoInversion() != null) {
            this.retornoInvRoi = this.roiDto.getRetornoInversion().multiply(this.dtoRequerimientoCapaRio.getInversion().divide(BigDecimal.valueOf(100)));
        }
    }

    public BigDecimal CalcularporcentajeAsistencia(BigDecimal horasAsist, BigDecimal horasCurso) {
        double hAsist = 0, hCurso = 0, rsult = 0;
        hAsist = horasAsist.doubleValue();
        hCurso = horasCurso.doubleValue();

        rsult = (hAsist * 100) / hCurso;

        return BigDecimal.valueOf(rsult);
    }

    public void eliminarAlumno() {
        try {
            if (this.alumnoDto.getId() != null) {
                this.alumnoManager.eliminar(this.alumnoDto);

                RequerimientoCapaDto reqAlum = new RequerimientoCapaDto();
                reqAlum = this.alumnoDto.getRequerimientoDto();
                reqAlum.setNumeroAlumnos(reqAlum.getNumeroAlumnos() - 1);
                this.requerimientoCapaManager.editar(reqAlum);

                this.cargarListaAlumno();
            }
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public void agregarEmpleado() {
        RequestContext context = RequestContext.getCurrentInstance();
        boolean resultado = true;
        PersonaDto dtoPersona = null;
        Long personaValor = 0L;
        try {
            List<AlumnoDto> listPost = new ArrayList<AlumnoDto>();
            AlumnoDto alumnoDtoAux = null;
            for (PersonaDto person : this.selectedPersona) {
                Long result = this.alumnoManager.obtenerIdEmpleado(person, this.dto);
                if (result.equals(0L)) {
                    alumnoDtoAux = new AlumnoDto();
                    alumnoDtoAux.setPersonaDto(person);
                    alumnoDtoAux.setRequerimientoDto(this.requerimientoCapaDto);
                    alumnoDtoAux.setEstado(Boolean.TRUE);
                    alumnoDtoAux.setCertificado(Boolean.FALSE);
                    this.alumnoManager.nuevo(alumnoDtoAux);
                    personaValor++;
                } else {
                    resultado = false;
                }
            }
            if (resultado) {
                showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
            } else {
                resultado = false;
                showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("popup.alumno.mensaje.repetidos"));
            }

            this.requerimientoCapaDto.setNumeroAlumnos(personaValor);
            this.requerimientoCapaManager.editar(this.requerimientoCapaDto);
        } catch (Exception ex) {
            resultado = false;
        }
        context.addCallbackParam("CallbackParam", resultado);
        this.cargarListaAlumno();
    }

    public void eliminarRequerimiento() {
        try {
            if (this.requerimientoCapaDto.getId() != null) {
                int numAlum = this.alumnoManager.obtenerListaAlumno(this.requerimientoCapaDto).size();
                if (numAlum == 0) {
                    this.requerimientoCapaDto.setProgramacionDto(null);
                    this.requerimientoCapaManager.editar(this.requerimientoCapaDto);
                    showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
                } else {
                    showError(UtilCore.Internacionalizacion.getMensajeInternacional("popup.alumno.requerimiento.mensaje.eliminar"));
                }
            }
            calcularInversion(2, this.dto, this.requerimientoCapaDto);
            obtenerListaRequerimiento();
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public void guardarRequerimientoFecha() {
        Boolean result = Boolean.FALSE;
        double valor=0;
        try {
            for (RequerimientoCapaDto r : this.listaRequerimiento) {
                valor+=r.getInversion().doubleValue();
                if (r.getFechaInicio() != null && r.getFechaFin() != null) {
                    if (UtilCore.Fecha.diferenciaDiasFechas(r.getFechaFin(), r.getFechaInicio()) > 0) {
                        showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("capacitacion.mensaje.error_fechas") + " " + r.getDescripcion());
                    } else {
                        System.out.print(valor);
                        this.requerimientoCapaManager.editar(r);
                         System.out.print(this.dto);
                        this.dto.setInversion(BigDecimal.valueOf(valor));
                        this.manager.editar(this.dto);
                        result = true;
                    }
                } else {
                    showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("capacitacion.mensaje.error_fechas"));
                }
            }
            if (result == true) {
                showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
            }
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        this.requerimientoCapaDto = new RequerimientoCapaDto();
        this.obtenerListaRequerimiento();
    }

    public void cargarPopupRequerimiento() {
        try {
            this.requerimientoCapaDto = new RequerimientoCapaDto();
            this.listaRequerimientoPopUp = this.requerimientoCapaManager.obtenerListaRequerimientos();

        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public void agregarRequerimiento() {
        RequestContext context = RequestContext.getCurrentInstance();
        boolean resultado = true;
        List<RequerimientoCapaDto> listReq = new ArrayList<RequerimientoCapaDto>();
        try {
            listReq = this.requerimientoCapaManager.obtenerListaRequerimientoProgramacion(this.dto);
            int totalReq = listReq.size();
            if (totalReq == 0) {
                this.dtoRequerimientoCapa.setProgramacionDto(this.dto);
                this.requerimientoCapaManager.editar(this.dtoRequerimientoCapa);
                this.calcularInversion(1, this.dto, this.dtoRequerimientoCapa);
                showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
            } else {
                if (listReq.get(0).getCursoDto().getId().equals(this.dtoRequerimientoCapa.getCursoDto().getId())) {
                    this.dtoRequerimientoCapa.setProgramacionDto(this.dto);
                    this.requerimientoCapaManager.editar(this.dtoRequerimientoCapa);
                    this.calcularInversion(1, this.dto, this.dtoRequerimientoCapa);
                    showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
                } else {
                    showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("popup.requerimiento.mensaje.error.curso")+" "+listReq.get(0).getCursoDto().getDescripcion());
                    resultado = false;
                }
            }
            
        } catch (Exception ex) {
            resultado = false;
        }
        context.addCallbackParam("CallbackParam", resultado);
        this.obtenerListaRequerimiento();
    }

    protected void calcularInversion(int ifVal, ProgramacionDto dtoPro, RequerimientoCapaDto dtoReq) {
        ProgramacionDto progr = new ProgramacionDto();
        double valor1, valor2, finalValor;
        progr = dtoPro;

        try {
            switch (ifVal) {
                case 1:
                    if (progr.getInversion().compareTo(BigDecimal.ZERO) > 0) {
                        valor1 = progr.getInversion().doubleValue();
                        valor2 = dtoReq.getInversion().doubleValue();
                        finalValor = valor1 + valor2;
                        progr.setInversion(BigDecimal.valueOf(finalValor));
                    } else {
                        progr.setInversion(dtoReq.getInversion());
                    }
                    break;
                default:
                    if (progr.getInversion().compareTo(BigDecimal.ZERO) > 0) {
                        valor1 = progr.getInversion().doubleValue();
                        valor2 = dtoReq.getInversion().doubleValue();
                        finalValor = valor1 - valor2;
                        progr.setInversion(BigDecimal.valueOf(finalValor));
                    } else {
                        progr.setInversion(BigDecimal.ZERO);
                    }
            }
            this.manager.editar(progr);
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public ProgramacionManager getManager() {
        return manager;
    }

    public void setManager(ProgramacionManager manager) {
        this.manager = manager;
    }

    public RecursosManager getRecursosManager() {
        return recursosManager;
    }

    public void setRecursosManager(RecursosManager recursosManager) {
        this.recursosManager = recursosManager;
    }

    public List<ProgramacionDto> getLista() {
        return lista;
    }

    public void setLista(List<ProgramacionDto> lista) {
        this.lista = lista;
    }

    public ProgramacionDto getDto() {
        return dto;
    }

    public void setDto(ProgramacionDto dto) {
        this.dto = dto;
    }

    public ProgramacionDto getDtoFiltro() {
        return dtoFiltro;
    }

    public void setDtoFiltro(ProgramacionDto dtoFiltro) {
        this.dtoFiltro = dtoFiltro;
    }

    public String getKeyTitulo() {
        return keyTitulo;
    }

    public void setKeyTitulo(String keyTitulo) {
        this.keyTitulo = keyTitulo;
    }

    public ApplicationMBean getApplicationMBean() {
        return applicationMBean;
    }

    public void setApplicationMBean(ApplicationMBean applicationMBean) {
        this.applicationMBean = applicationMBean;
    }

    public SessionMBean getSessionMBean() {
        return sessionMBean;
    }

    public void setSessionMBean(SessionMBean sessionMBean) {
        this.sessionMBean = sessionMBean;
    }

    public List<ParametroDto> getListaEstadosFiltro() {
        return this.recursosManager.obtenerParametrosActivosPorCatalogoSistemaAdd(ConstantesCapa.CatalogoParametro.PROGRAMACION_ESTADOS, ConstantesCore.Parametro.TODOS);
    }

    public void setListaEstadosFiltro(List<ParametroDto> listaEstadosFiltro) {
        this.listaEstadosFiltro = listaEstadosFiltro;
    }

    public List<ParametroDto> getListaEstados() {
        return this.recursosManager.obtenerParametrosActivosPorCatalogoSistema(ConstantesCapa.CatalogoParametro.PROGRAMACION_ESTADOS);
    }

    public void setListaEstados(List<ParametroDto> listaEstados) {
        this.listaEstados = listaEstados;
    }

    public static Logger getLogger() {
        return logger;
    }

    public static void setLogger(Logger logger) {
        ProgramacionMBean.logger = logger;
    }

    public boolean isAccesoAnular() {
        return accesoAnular;
    }

    public void setAccesoAnular(boolean accesoAnular) {
        this.accesoAnular = accesoAnular;
    }

    public boolean isAccesoGuardar() {
        return accesoGuardar;
    }

    public void setAccesoGuardar(boolean accesoGuardar) {
        this.accesoGuardar = accesoGuardar;
    }

    public List<RequerimientoCapaDto> getListaRequerimiento() {
        return listaRequerimiento;
    }

    public void setListaRequerimiento(List<RequerimientoCapaDto> listaRequerimiento) {
        this.listaRequerimiento = listaRequerimiento;
    }

    public RequerimientoCapaDto getRequerimientoCapaDto() {
        return requerimientoCapaDto;
    }

    public void setRequerimientoCapaDto(RequerimientoCapaDto requerimientoCapaDto) {
        this.requerimientoCapaDto = requerimientoCapaDto;
    }

    public RequerimientoCapaDto[] getSelectedRquerimiento() {
        return selectedRquerimiento;
    }

    public void setSelectedRquerimiento(RequerimientoCapaDto[] selectedRquerimiento) {
        this.selectedRquerimiento = selectedRquerimiento;
    }

    public RequerimientoCapaDto getDtoRequerimientoCapa() {
        return dtoRequerimientoCapa;
    }

    public void setDtoRequerimientoCapa(RequerimientoCapaDto dtoRequerimientoCapa) {
        this.dtoRequerimientoCapa = dtoRequerimientoCapa;
    }

    public List<AlumnoDto> getListaAlumno() {
        return listaAlumno;
    }

    public void setListaAlumno(List<AlumnoDto> listaAlumno) {
        this.listaAlumno = listaAlumno;
    }

    public AlumnoDto getAlumnoDto() {
        return alumnoDto;
    }

    public void setAlumnoDto(AlumnoDto alumnoDto) {
        this.alumnoDto = alumnoDto;
    }

    public PersonaDto[] getSelectedPersona() {
        return selectedPersona;
    }

    public void setSelectedPersona(PersonaDto[] selectedPersona) {
        this.selectedPersona = selectedPersona;
    }

    public boolean isValidarEliminarReq() {
        return validarEliminarReq;
    }

    public void setValidarEliminarReq(boolean validarEliminarReq) {
        this.validarEliminarReq = validarEliminarReq;
    }

    public AlumnoDto getAlumnoDetalleDto() {
        return alumnoDetalleDto;
    }

    public void setAlumnoDetalleDto(AlumnoDto alumnoDetalleDto) {
        this.alumnoDetalleDto = alumnoDetalleDto;
    }

    public Date getFechaActual() {
        return UtilCore.Fecha.agregarDiasFechaDate(UtilCore.Fecha.obtenerFechaActualDate(), 0);
    }

    public void setFechaActual(Date fechaActual) {
        this.fechaActual = fechaActual;
    }

    public int getNumAlumnos() {
        return numAlumnos;
    }

    public void setNumAlumnos(int numAlumnos) {
        this.numAlumnos = numAlumnos;
    }

    public boolean isAccesoConvocado() {
        return accesoConvocado;
    }

    public void setAccesoConvocado(boolean accesoConvocado) {
        this.accesoConvocado = accesoConvocado;
    }

    public boolean isAccesoEjecutado() {
        return accesoEjecutado;
    }

    public void setAccesoEjecutado(boolean accesoEjecutado) {
        this.accesoEjecutado = accesoEjecutado;
    }

    public boolean isValidarEstadoAcciones() {
        return validarEstadoAcciones;
    }

    public void setValidarEstadoAcciones(boolean validarEstadoAcciones) {
        this.validarEstadoAcciones = validarEstadoAcciones;
    }

    public boolean isValidarEstadoAccionesEjecutado() {
        return validarEstadoAccionesEjecutado;
    }

    public void setValidarEstadoAccionesEjecutado(boolean validarEstadoAccionesEjecutado) {
        this.validarEstadoAccionesEjecutado = validarEstadoAccionesEjecutado;
    }

    public RoiDto getRoiDto() {
        return roiDto;
    }

    public void setRoiDto(RoiDto roiDto) {
        this.roiDto = roiDto;
    }

    public List<RoiDto> getListaRoi() {
        return listaRoi;
    }

    public void setListaRoi(List<RoiDto> listaRoi) {
        this.listaRoi = listaRoi;
    }

    public RequerimientoCapaDto getDtoRequerimientoCapaRio() {
        return dtoRequerimientoCapaRio;
    }

    public void setDtoRequerimientoCapaRio(RequerimientoCapaDto dtoRequerimientoCapaRio) {
        this.dtoRequerimientoCapaRio = dtoRequerimientoCapaRio;
    }

    public BigDecimal getRetornoInvRoi() {
        return retornoInvRoi;
    }

    public void setRetornoInvRoi(BigDecimal retornoInvRoi) {
        this.retornoInvRoi = retornoInvRoi;
    }

    public List<RequerimientoCapaDto> getListaRequerimientoPopUp() {
        return listaRequerimientoPopUp;
    }

    public void setListaRequerimientoPopUp(List<RequerimientoCapaDto> listaRequerimientoPopUp) {
        this.listaRequerimientoPopUp = listaRequerimientoPopUp;
    }
    
}
